//
// Created on 2024/11/14.
//
// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
// please include "napi/native_api.h".

#include "ui_motion_animation_capi_animator_test.h"
#include "common/common.h"
#include <arkui/native_animate.h>
#include <arkui/native_interface.h>
#include <arkui/native_type.h>
#include "arkui/drag_and_drop.h"
#include <string>
#include <sstream>

static ArkUI_AttributeItem text_item = {};
static ArkUI_AnimatorHandle animatorHandle = nullptr;
static ArkUI_AnimatorOption *animatorOption = nullptr;
static ArkUI_KeyframeAnimateOption *option = nullptr;
static ArkUI_NativeAnimateAPI_1 *animateApi = nullptr;
static ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;

static ArkUI_NodeHandle showContent = nullptr;
static ArkUI_NodeHandle pause = nullptr;
static ArkUI_NodeHandle play = nullptr;
static ArkUI_NodeHandle reverse = nullptr;
static ArkUI_NodeHandle create = nullptr;
static ArkUI_NodeHandle onCancel = nullptr;
static ArkUI_NodeHandle onFinish = nullptr;
static ArkUI_NodeHandle textInput = nullptr;
static ArkUI_NodeHandle button1 = nullptr;
static ArkUI_NodeHandle button2 = nullptr;
static ArkUI_NodeHandle button3 = nullptr;
static ArkUI_NodeHandle playButton = nullptr;
static ArkUI_NodeHandle createButton = nullptr;
static ArkUI_NodeHandle logText = nullptr;

static bool flag = false;
static int NUMBER_INDEX = 0;
static int NUMBER_0 = 0;
static int NUMBER_1 = 1;
static int NUMBER_2 = 2;
static int NUMBER_3 = 3;
static int NUMBER_5 = 5;
static int NUMBER_50 = 50;
static int NUMBER_100 = 100;
static int NUMBER_200 = 200;
static int NUMBER_300 = 300;
static int NUMBER_500 = 500;
static int NUMBER_1000 = 1000;
static int NUMBER_3000 = 3000;
static int NUMBER_SHOW_CONTENT = 9901;
static int NUMBER_START_TO_ANIMATOR = 9902;
static int NUMBER_CREATE_ANIMATOR = 9903;
static int NUMBER_CREATE_OPTION = 9904;
static int NUMBER_PAUSE_ANIMATOR = 9905;
static int NUMBER_ONCANCEL_ANIMATOR = 9906;
static int NUMBER_ONFINISH_ANIMATOR = 9907;
static int NUMBER_REVERSE_ANIMATOR = 9908;
static int TEST_17 = 17;
static int TEST_19 = 19;
static int TEST_21 = 21;
static int TEST_23 = 23;
static int TEST_24 = 24;
static int TEST_25 = 25;
static int TEST_26 = 26;
static int TEST_27 = 27;
static int TEST_28 = 28;
static int TEST_31 = 31;
static int TEST_32 = 32;
static int TEST_33 = 33;
static int TEST_67 = 67;
static int TEST_68 = 68;
static int TEST_69 = 69;
static int TEST_70 = 70;
static int TEST_71 = 71;
static int TEST_72 = 72;
static int TEST_73 = 73;
static int TEST_74 = 74;
static int TEST_75 = 75;
static int TEST_76 = 76;
static int TEST_77 = 77;
static int TEST_78 = 78;
static int TEST_79 = 79;
static int TEST_80 = 80;
static int TEST_81 = 81;
static int TEST_82 = 82;

namespace ArkUICApiDemo {

static void CreateRegisterOnFrameCallback()
{
    OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr,
        [](ArkUI_AnimatorOnFrameEvent *event) {
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorRegisterOnFrame",
            "OnEventReceive: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);

        float progress = OH_ArkUI_AnimatorOnFrameEvent_GetValue(event);
        ArkUI_NumberValue heightValue[] = {progress * 100};
        ArkUI_AttributeItem heightItem = {heightValue, 1};
        nodeAPI->setAttribute(button3, NODE_HEIGHT, &heightItem);
        ArkUI_NumberValue widthValue[] = {progress * 100};
        ArkUI_AttributeItem widthItem = {widthValue, 1};
        nodeAPI->setAttribute(button3, NODE_WIDTH, &widthItem);
    });
}

static void SetNodeWidthAndHeight(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode, float width, float height)
{
    ArkUI_NumberValue width_value[] = {{.f32 = width}};
    ArkUI_AttributeItem width_item = {width_value, sizeof(width_value) / sizeof(ArkUI_NumberValue)};
    nodeAPI->setAttribute(rootNode, NODE_WIDTH, &width_item);
    ArkUI_NumberValue height_value[] = {{.f32 = height}};
    ArkUI_AttributeItem height_item = {height_value, sizeof(height_value) / sizeof(ArkUI_NumberValue)};
    nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &height_item);
}

static void CreateAnimatorOption(int32_t keyframeSize)
{
    animatorOption = OH_ArkUI_AnimatorOption_Create(keyframeSize);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, NUMBER_3000);
    OH_ArkUI_AnimatorOption_SetBegin(animatorOption, NUMBER_100);
    OH_ArkUI_AnimatorOption_SetEnd(animatorOption, NUMBER_300);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 1, 2);
    CreateRegisterOnFrameCallback();
}

static void CreateAnimatorTestOption(int32_t keyframeSize)
{
    animatorOption = OH_ArkUI_AnimatorOption_Create(keyframeSize);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 1000);
    OH_ArkUI_AnimatorOption_SetBegin(animatorOption, 1);
    OH_ArkUI_AnimatorOption_SetEnd(animatorOption, 5);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.3, 0.2, 0);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.6, 0.5, 1);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 1, 2);
    OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, [](ArkUI_AnimatorOnFrameEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest",
                "OnEventReceive: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);

        float progress = OH_ArkUI_AnimatorOnFrameEvent_GetValue(event);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "progress %{public}f", progress);
        ArkUI_NumberValue heightValue[] = {progress * 100};
        ArkUI_AttributeItem heightItem = {heightValue, 1};
        nodeAPI->setAttribute(playButton, NODE_HEIGHT, &heightItem);
        ArkUI_NumberValue widthValue[] = {progress * 100};
        ArkUI_AttributeItem widthItem = {widthValue, 1};
        nodeAPI->setAttribute(playButton, NODE_WIDTH, &widthItem);
    });
}

static auto CreateBaseText(ArkUI_NativeNodeAPI_1 *nodeAPI, std::string &componentId)
{
    auto baseText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    ArkUI_NumberValue width_value[] = {{.f32 = SIZE_300}};
    ArkUI_NumberValue height_value[] = {{.f32 = SIZE_100}};
    ArkUI_AttributeItem width_item = {width_value, sizeof(width_value) / sizeof(ArkUI_NumberValue)};
    ArkUI_AttributeItem height_item = {height_value, sizeof(height_value) / sizeof(ArkUI_NumberValue)};
    nodeAPI->setAttribute(baseText, NODE_WIDTH, &width_item);
    nodeAPI->setAttribute(baseText, NODE_HEIGHT, &height_item);
    ArkUI_AttributeItem place_holder_item;
    place_holder_item.string = "print log: ";
    nodeAPI->setAttribute(baseText, NODE_TEXT_CONTENT, &place_holder_item);
    ArkUI_AttributeItem idStr;
    idStr.string = componentId.c_str();
    nodeAPI->setAttribute(baseText, NODE_ID, &idStr);
    return baseText;
}

static auto CreateButtonWithIDAndName(ArkUI_NativeNodeAPI_1 *nodeAPI, const char* componentId, const char* buttonName)
{
    auto button = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button, 200, 100);
    ArkUI_AttributeItem idStr;
    idStr.string = componentId;
    nodeAPI->setAttribute(button, NODE_ID, &idStr);
    nodeAPI->registerNodeEvent(button, NODE_ON_CLICK, ON_CLICK_EVENT_ID, nullptr);
    ArkUI_AttributeItem text_item = {nullptr, 0, buttonName};
    nodeAPI->setAttribute(button, NODE_BUTTON_LABEL, &text_item);
    return button;
}

static void AnimatorEvent(ArkUI_AnimatorOption *&animatorOption)
{
    OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, [](ArkUI_AnimatorOnFrameEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OnEventReceiveL");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorRegisterOnFrame",
                         "OnEventReceiveL: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        float progress = OH_ArkUI_AnimatorOnFrameEvent_GetValue(event);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "progress %{public}f", progress);
        OH_ArkUI_AnimatorOnFrameEvent_GetUserData(event);
        SetNodeWidthAndHeight(nodeAPI, textInput, progress * NUMBER_300, progress * NUMBER_200);
    });
    OH_ArkUI_AnimatorOption_RegisterOnCancelCallback(animatorOption, nullptr, [](ArkUI_AnimatorEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OnEventReceiveL CancelCallback");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption_RegisterOnCancelCallback",
                         "OnEventReceiveL: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        void *userData = OH_ArkUI_AnimatorEvent_GetUserData(event);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
                     "OH_ArkUl_AnimatorOption_onCancel UserData %{public}xp", &userData);

        if (NUMBER_INDEX != TEST_27) {
            return;
        }
        unsigned long long address = reinterpret_cast<unsigned long long>(&userData);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "OnCancelCallback UserData：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    });
    OH_ArkUI_AnimatorOption_RegisterOnFinishCallback(animatorOption, nullptr, [](ArkUI_AnimatorEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OnEventReceiveL FinishCallback");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption_RegisterOnFinishCallback",
                         "OnEventReceiveL: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        void *userData = OH_ArkUI_AnimatorEvent_GetUserData(event);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
                     "OH_ArkUl_AnimatorOption_SetOnFinish UserData %{public}xp", &userData);

        if (NUMBER_INDEX != TEST_25 || NUMBER_INDEX != TEST_23 || NUMBER_INDEX != TEST_24) {
            return;
        }
        unsigned long long address = reinterpret_cast<unsigned long long>(&userData);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "OnFinishCallback UserData：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    });
    OH_ArkUI_AnimatorOption_RegisterOnRepeatCallback(animatorOption, nullptr, [](ArkUI_AnimatorEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OnEventReceiveL RepeatCallback");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption_RegisterOnRepeatCallback",
                         "OnEventReceiveL: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        void *userData = OH_ArkUI_AnimatorEvent_GetUserData(event);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
                     "OH_ArkUl_AnimatorOption_onRepeat UserData %{public}xp", &userData);

        if (NUMBER_INDEX != TEST_28) {
            return;
        }
        unsigned long long address = reinterpret_cast<unsigned long long>(&userData);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "OnRepeatCallback UserData：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    });
}

static void OnEventReceiveL(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);

    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(textInput);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    } else if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    } else if (targetId == NUMBER_PAUSE_ANIMATOR) {
        auto ret = OH_ArkUI_Animator_Pause(animatorHandle);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
                     "CreateNativeNode retCode_pause== %{public}d", ret);
        std::string errorCode = "retCode_pause：";
        errorCode += std::to_string(ret);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    } else if (targetId == NUMBER_ONCANCEL_ANIMATOR) {
        OH_ArkUI_Animator_Cancel(animatorHandle);
    } else if (targetId == NUMBER_ONFINISH_ANIMATOR) {
        OH_ArkUI_Animator_Finish(animatorHandle);
    } else if (targetId == NUMBER_REVERSE_ANIMATOR) {
        auto ret = OH_ArkUI_Animator_Reverse(animatorHandle);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
                     "CreateNativeNode retCode_Reverse== %{public}d", ret);
        std::string errorCode = "retCode_Reverse：";
        errorCode += std::to_string(ret);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
}

static void CreateAnimatorTestLOption(int index)
{
    if (index == TEST_67) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 50, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0, 200.5, 1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 350, 2);
    } else if (index == TEST_68) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, -1, 50, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 200.5, 1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 350, 2);
    } else if (index == TEST_69) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0, 50, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 200.5, 1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1.5, 350, 2);
    } else if (index == TEST_70) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0, 200, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 50.5, 1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 350, 2);
    } else if (index == TEST_71) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0, 50, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 200.5, 1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 350, 10);
    } else if (index == TEST_72) {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_3);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0, 50, -1);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5, 200.5, 0);
        OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 350, 1);
    } else {
        animatorOption = OH_ArkUI_AnimatorOption_Create(NUMBER_100);
        for (int i = 0; i < 100; ++i) {
            OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.01 * (i + 1), 0.01 * i, i);
        }
    }
    OH_ArkUI_AnimatorOption_SetBegin(animatorOption, 0);
    OH_ArkUI_AnimatorOption_SetEnd(animatorOption, NUMBER_5);

    auto ret = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto ret2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto ret3 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
        "GetKeyframeValue=0== %{public}f、GetKeyframeValue=1== %{public}f、GetKeyframeValue=2== %{public}f",
        ret, ret2, ret3);
    ret = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    ret2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    ret3 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
        "GetKeyframeTime=0== %{public}f、GetKeyframeTime=1== %{public}f、GetKeyframeTime=2== %{public}f",
        ret, ret2, ret3);

    if (index == TEST_25 || index == TEST_28) {
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, NUMBER_5);
    }
    if (index == TEST_31) {
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 0);
    } else if (index == TEST_32) {
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, NUMBER_500);
    } else if (index == TEST_33) {
        auto retDuration = OH_ArkUI_AnimatorOption_GetDuration(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
                     "OH_ArkUI_AnimatorOption_GetDuration ==%{public}d", retDuration);
    } else if (index == TEST_23) {
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 2000);
    } else if (index == TEST_21) {
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 3000);
    } else {
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 500);
    }

    auto retDuration = OH_ArkUI_AnimatorOption_GetDuration(animatorOption);
    OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
                 "OH_ArkUI_AnimatorOption_GetDuration ==%{public}d", retDuration);
    auto retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
    OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
                 "OH_ArkUI_AnimatorOption_GetIterations ==%{public}d", retIterations);

    if (index == TEST_73) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_EASE);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_74) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_LINEAR);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_75) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_EASE_IN);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_76) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_EASE_OUT);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_77) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_EASE_IN_OUT);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_78) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_FAST_OUT_SLOW_IN);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_79) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_FAST_OUT_LINEAR_IN);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_80) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_LINEAR_OUT_SLOW_IN);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_81) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_FRICTION);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else if (index == TEST_82) {
        ArkUI_CurveHandle curve = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_EXTREME_DECELERATION);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curve, 1);
    } else {
    }

    auto retCurve = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "CreateNativeNode",
                 "OH_ArkUl_AnimatorOption_GetKeyframeCurve=1== %{public}xp", retCurve);

    AnimatorEvent(animatorOption);
}

static void CreateAnimatorTestLWOption(int a)
{
    animatorOption = OH_ArkUI_AnimatorOption_Create(a);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, NUMBER_3000);
    OH_ArkUI_AnimatorOption_SetBegin(animatorOption, 0);
    OH_ArkUI_AnimatorOption_SetEnd(animatorOption, 5);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.3, 1, 0);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.6, 2, 1);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 3, 2);
    OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, [](ArkUI_AnimatorOnFrameEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OnEventReceive");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorRegisterOnFrame", "OnEventReceive: event is null");
            return;
        }
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        float progress = OH_ArkUI_AnimatorOnFrameEvent_GetValue(event);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "progress %{public}f",progress);
        ArkUI_NumberValue heightValue[] = {progress*100};
        ArkUI_AttributeItem heightItem = {heightValue, 100};
        nodeAPI->setAttribute(play, NODE_HEIGHT, &heightItem);
        ArkUI_NumberValue widthValue[] = {progress*100};
        ArkUI_AttributeItem widthItem = {widthValue, 1};
        nodeAPI->setAttribute(play, NODE_WIDTH, &widthItem);
    });
}

static void SetNodeID(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode, float width, float height, std::string& componentsId)
{
    ArkUI_NumberValue width_value[] = {{.f32 = width}};
    ArkUI_AttributeItem width_item = {width_value, sizeof(width_value) / sizeof(ArkUI_NumberValue)};
    nodeAPI->setAttribute(rootNode, NODE_WIDTH, &width_item);
    ArkUI_NumberValue height_value[] = {{.f32 = height}};
    ArkUI_AttributeItem height_item = {height_value, sizeof(height_value) / sizeof(ArkUI_NumberValue)};
    nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &height_item);
    ArkUI_AttributeItem id_item = {};
    id_item.string = componentsId.c_str();
    nodeAPI->setAttribute(rootNode, NODE_ID, &id_item);
}

void SetNodeButtonLabelAndEvent(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle &nodeHandle, std::string name, int eventId)
{
    nodeHandle = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    if (nodeHandle == nullptr) {
        return;
    }
    SetNodeWidthAndHeight(nodeAPI, nodeHandle, NUMBER_200, NUMBER_100);
    ArkUI_AttributeItem createNode_Button_Label_Item = {.string = name.c_str()};
    nodeAPI->setAttribute(nodeHandle, NODE_BUTTON_LABEL, &createNode_Button_Label_Item);
    ArkUI_AttributeItem idStr;
    idStr.string = name.c_str();
    nodeAPI->setAttribute(nodeHandle, NODE_ID, &idStr);
    nodeAPI->registerNodeEvent(nodeHandle, NODE_ON_CLICK, eventId, nullptr);
}

void SetNodeTextInput(ArkUI_NativeNodeAPI_1 **nodeAPI, ArkUI_NodeHandle &nodeHandle)
{
    nodeHandle = (*nodeAPI)->createNode(ARKUI_NODE_TEXT_INPUT);
    if (nodeHandle == nullptr) {
        return;
    }
    SetNodeWidthAndHeight(*nodeAPI, nodeHandle, NUMBER_300, NUMBER_200);
    ArkUI_NumberValue background_color_value[] = {{.u32 = COLOR_BLUE}};
    ArkUI_AttributeItem background_color_item = {background_color_value,
                                                 sizeof(background_color_value) / sizeof(ArkUI_NumberValue)};
    (*nodeAPI)->setAttribute(nodeHandle, NODE_BACKGROUND_COLOR, &background_color_item);
    ArkUI_AttributeItem place_holder_item;
    place_holder_item.string = "hello world";
    ArkUI_NumberValue font_value[] = {
        {.f32 = 20.0}, {.i32 = ARKUI_FONT_STYLE_NORMAL}, {.i32 = ARKUI_FONT_WEIGHT_NORMAL}};
    ArkUI_AttributeItem font_item = {font_value, sizeof(font_value) / sizeof(ArkUI_NumberValue)};
    (*nodeAPI)->setAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &font_item);
    (*nodeAPI)->setAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER, &place_holder_item);
}

namespace CreateAnimator {
static ArkUI_ExpectedFrameRateRange rateRangeValue = {};
static void OnEventReceive(ArkUI_NodeEvent *event)
{
    if (event == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive: event is null");
        return;
    }
    int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);

    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    auto nodeHandler = OH_ArkUI_NodeEvent_GetNodeHandle(event);
    auto nodeName = nodeAPI->getAttribute(nodeHandler, NODE_BUTTON_LABEL);

    if (eventId != ON_CLICK_EVENT_ID) {
        return;
    }
    if (strcmp(nodeName->string, "create") == 0){
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(nodeHandler);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        if(animatorHandle == NULL){
            text_item.string = "AnimatorAnimatorCTest Creates animator fail";
        }else{
            text_item.string = "AnimatorAnimatorCTest Creates animator success";
        }
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
        return;
    }
    if(strcmp(nodeName->string, "play") == 0){
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0010(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0010", "create");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0010";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&CreateAnimator::OnEventReceive);
    CreateAnimatorTestOption(0);
}

static ArkUI_NodeHandle text0020;
static void OnEventReceive0020(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN,
            "Manager", "CreateNativeNodeAnimator0020: targetId : %{public}d ", targetId);
    }
    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        animatorHandle = animateApi->createAnimator(nullptr, animatorOption);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN,
            "Manager", "CreateNativeNodeAnimator0020: targetId : %{public}d ", targetId);
    }
    if (targetId == NUMBER_2) {
        auto code = OH_ArkUI_Animator_Play(animatorHandle);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN,
            "Manager", "CreateNativeNodeAnimator0020: errorCode : %{public}d ", code);
        ArkUI_AttributeItem place_holder_item;
        std::string errorCode = "code reset：";
        errorCode += std::to_string(code);
        place_holder_item.string = errorCode.c_str();
        nodeAPI->setAttribute(text0020, NODE_TEXT_CONTENT, &place_holder_item);
    }
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0020(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0020_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0020_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0020_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0020);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
    text0020 = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, text0020);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0030(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0030", "create");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0030";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&CreateAnimator::OnEventReceive);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0040(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0040_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0040_P", "play");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0040";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&CreateAnimator::OnEventReceive);
    CreateAnimatorTestOption(3);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0050(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0050_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0050_P", "play");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0050";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&CreateAnimator::OnEventReceive);
    CreateAnimatorTestOption(0);
}

static void OnEventReceive0060(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(1);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0060(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0060_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0060_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0060_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0060);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0070(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0070_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0070_P", "play");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0070";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&CreateAnimator::OnEventReceive);
    CreateAnimatorTestOption(-1);
}

namespace PlayControl{
static ArkUI_ExpectedFrameRateRange rateRangeValue = {};
static ArkUI_NodeHandle disposeOptionButton = nullptr;
static ArkUI_NodeHandle resetButton = nullptr;
static ArkUI_NodeHandle pauseButton = nullptr;
static ArkUI_NodeHandle reverseButton = nullptr;
static ArkUI_NodeHandle finishButton = nullptr;
static ArkUI_NodeHandle cancelButton = nullptr;
static int32_t code = 0;
static void SetCallBack()
{
    OH_ArkUI_AnimatorOption_RegisterOnFinishCallback(animatorOption, nullptr, [](ArkUI_AnimatorEvent* event) {
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        if (event == nullptr) {
            text_item.string = "AnimatorAnimatorCTest OnEventReceive: event is null";
            nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);    
            return;
        }
        std::string log = "CreateNativeNode retCode_finish == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    });
    
    OH_ArkUI_AnimatorOption_RegisterOnCancelCallback(animatorOption, nullptr, [](ArkUI_AnimatorEvent* event) {
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        if (event == nullptr) {
            text_item.string = "AnimatorAnimatorCTest OnEventReceive: event is null";
            nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);    
            return;
        }
        std::string log = "CreateNativeNode retCode_cancel == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    });
}
static void OnEventReceive(ArkUI_NodeEvent *event)
{
    if (event == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive: event is null");
        return;
    }

    int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);
    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    auto nodeHandler = OH_ArkUI_NodeEvent_GetNodeHandle(event);
    auto nodeName = nodeAPI->getAttribute(nodeHandler, NODE_BUTTON_LABEL);

    if (eventId != ON_CLICK_EVENT_ID) {
        return;
    }
    if (strcmp(nodeName->string, "create") == 0){
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(nodeHandler);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        if(animatorHandle == NULL){
            text_item.string = "AnimatorAnimatorCTest Creates animator fail";
        }
        text_item.string = "AnimatorAnimatorCTest Creates animator success";
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if(strcmp(nodeName->string, "play") == 0){
        int32_t code = OH_ArkUI_Animator_Play(animatorHandle);
        std::string log = "CreateNativeNode retCode_play== " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
        return;
    }
    if(strcmp(nodeName->string, "disposeOption") == 0){
        OH_ArkUI_AnimatorOption_Dispose(nullptr);
    }
    if(strcmp(nodeName->string, "reset") == 0){
        OH_ArkUI_Animator_ResetAnimatorOption(animatorHandle, animatorOption);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "reset AnimatorOption success");
    }
    if(strcmp(nodeName->string, "pause") == 0){
        int32_t code = OH_ArkUI_Animator_Pause(animatorHandle);
        std::string log = "CreateNativeNode retCode_pause == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item); 
    }
    if(strcmp(nodeName->string, "reserve") == 0){
        int32_t code = OH_ArkUI_Animator_Reverse(animatorHandle);
        std::string log = "CreateNativeNode retCode_pause == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item); 
    }
    if(strcmp(nodeName->string, "finish130") == 0){
        code = OH_ArkUI_Animator_Finish(animatorHandle);
        std::string log = "CreateNativeNode retCode_finish == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if(strcmp(nodeName->string, "cancel150") == 0){
        code = OH_ArkUI_Animator_Cancel(animatorHandle);
        std::string log = "CreateNativeNode retCode_cancel == " + std::to_string(code);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if(strcmp(nodeName->string, "finish") == 0){
        code = OH_ArkUI_Animator_Finish(animatorHandle);
    }
    if(strcmp(nodeName->string, "cancel") == 0){
        code = OH_ArkUI_Animator_Cancel(animatorHandle);
    }    
}
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0080(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0080_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0080_P", "play");
    PlayControl::disposeOptionButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0080_D", "disposeOption");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0080";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, PlayControl::disposeOptionButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

static ArkUI_NodeHandle text0090;
static void OnEventReceive0090(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    }
    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    if (targetId == NUMBER_2) {
        auto code = OH_ArkUI_Animator_Play(animatorHandle);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN,
            "Manager", "CreateNativeNodeAnimator0090: play code : %{public}d ", code);
        ArkUI_AttributeItem place_holder_item;
        std::string errorCode = "retCode_play：";
        errorCode += std::to_string(code);
        place_holder_item.string = errorCode.c_str();
        nodeAPI->setAttribute(text0090, NODE_TEXT_CONTENT, &place_holder_item);
    }
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0090(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0090_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0090_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0090_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0090);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
    text0090 = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, text0090);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0100(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0100_P", "play");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0100";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

static ArkUI_NodeHandle text0110;
static void OnEventReceive0110(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        animatorHandle = nullptr;
        int32_t result = OH_ArkUI_Animator_ResetAnimatorOption(animatorHandle, animatorOption);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN,
            "Manager", "CreateNativeNodeAnimator0110: retCode_reset result : %{public}d ", result);
        ArkUI_AttributeItem place_holder_item;
        std::string errorCode = "retCode_reset：";
        errorCode += std::to_string(result);
        place_holder_item.string = errorCode.c_str();
        nodeAPI->setAttribute(text0110, NODE_TEXT_CONTENT, &place_holder_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0110(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    text0110 = nodeAPI->createNode(ARKUI_NODE_TEXT);
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0110_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0110_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "reset"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0110_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0110);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
    nodeAPI->addChild(rootNode, text0110);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0120(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0120_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0120_P", "play");
    PlayControl::resetButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0120_R", "reset");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0120";
    logText = CreateBaseText(nodeAPI,componentId);    
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, PlayControl::resetButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0130(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    PlayControl::finishButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0130_F", "finish130");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0130";
    logText = CreateBaseText(nodeAPI,componentId);    
    nodeAPI->addChild(rootNode, PlayControl::finishButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0140(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0140_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0140_P", "play");
    PlayControl::finishButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0140_F", "finish");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0140";
    logText = CreateBaseText(nodeAPI,componentId);    
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, PlayControl::finishButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
    PlayControl::SetCallBack();
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0150(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    PlayControl::cancelButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0150_L", "cancel150");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0150";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, PlayControl::cancelButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);    
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0160(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0160_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0160_P", "play");
    PlayControl::cancelButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0160_L", "cancel");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0160";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, PlayControl::cancelButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
    PlayControl::SetCallBack();
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0170(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, pause, "pause", NUMBER_PAUSE_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_17);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, pause);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0180(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0180_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0180_P", "play");
    PlayControl::pauseButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0180_S", "pause");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0180";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, PlayControl::pauseButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0190(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, reverse, "reverse", NUMBER_REVERSE_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_19);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, reverse);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0200(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0200_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0200_P", "play");
    PlayControl::reverseButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0200_R", "reserve");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0200";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, PlayControl::reverseButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption(0);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0210(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, reverse, "reverse", NUMBER_REVERSE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, pause, "pause", NUMBER_PAUSE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, onFinish, "finish", NUMBER_ONFINISH_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, onCancel, "cancel", NUMBER_ONCANCEL_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_21);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, pause);
    nodeAPI->addChild(rootNode, reverse);
    nodeAPI->addChild(rootNode, onCancel);
    nodeAPI->addChild(rootNode, onFinish);
    nodeAPI->addChild(rootNode, textInput);
}


static void CreateAnimatorTestOption0220(int32_t keyframeSize)
{
    animatorOption = OH_ArkUI_AnimatorOption_Create(keyframeSize);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 1000);
    OH_ArkUI_AnimatorOption_SetBegin(animatorOption, 1);
    OH_ArkUI_AnimatorOption_SetEnd(animatorOption, 5);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.3, 0.2, 0);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.6, 0.5, 1);
    OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 1, 1, 2);
    OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, [](ArkUI_AnimatorOnFrameEvent *event) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest",
            "OH_ArkUI_AnimatorOption_RegisterOnFrameCallback");
        if (event == nullptr) {
            OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest",
                "OnEventReceive: event is null");
            return;
        }

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        text_item.string = " log : OH_ArkUI_AnimatorOption_RegisterOnFrameCallback";
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);

        float progress = OH_ArkUI_AnimatorOnFrameEvent_GetValue(event);
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "progress %{public}f", progress);
        ArkUI_NumberValue heightValue[] = {progress * 100};
        ArkUI_AttributeItem heightItem = {heightValue, 1};
        nodeAPI->setAttribute(playButton, NODE_HEIGHT, &heightItem);
        ArkUI_NumberValue widthValue[] = {progress * 100};
        ArkUI_AttributeItem widthItem = {widthValue, 1};
        nodeAPI->setAttribute(playButton, NODE_WIDTH, &widthItem);
    });
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0220(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0220_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0220_P", "play");
    std::string componentId = "";
    logText = CreateBaseText(nodeAPI, componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&PlayControl::OnEventReceive);
    CreateAnimatorTestOption0220(0);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0230(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, onFinish, "finish", NUMBER_ONFINISH_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_23);
    NUMBER_INDEX = TEST_23;
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, onFinish);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0240(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_24);
    NUMBER_INDEX = TEST_24;
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0250(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_25);
    NUMBER_INDEX = TEST_25;
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0260(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, onFinish, "finish", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_26);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, onFinish);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0270(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, onCancel, "cancel", NUMBER_ONCANCEL_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_27);
    NUMBER_INDEX = TEST_27;
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, onCancel);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0280(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_28);
    NUMBER_INDEX = TEST_28;
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0310(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_31);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);

    auto retDuration = OH_ArkUI_AnimatorOption_GetDuration(animatorOption);
    std::string errorCode = "OH_ArkUI_AnimatorOption_GetDuration：";
    errorCode += std::to_string(retDuration);
    text_item.string = errorCode.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0320(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_32);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);

    auto retDuration = OH_ArkUI_AnimatorOption_GetDuration(animatorOption);
    std::string errorCode = "OH_ArkUI_AnimatorOption_GetDuration：";
    errorCode += std::to_string(retDuration);
    text_item.string = errorCode.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0330(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_33);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto retDuration = OH_ArkUI_AnimatorOption_GetDuration(animatorOption);
    std::string errorCode = "OH_ArkUI_AnimatorOption_GetDuration：";
    errorCode += std::to_string(retDuration);
    text_item.string = errorCode.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

static void OnEventReceive0340(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);

    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(0);
        OH_ArkUI_AnimatorOption_SetDelay(animatorOption, 3000.5);
        
        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retDelay = OH_ArkUI_AnimatorOption_GetDelay(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkULAnimatorOption_GetDelay == %{public}d", retDelay);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetDelay：";
        errorCode += std::to_string(retDelay);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);

        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0340(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string delayId = "delay0340";
    SetNodeID(nodeAPI, showContent, 200, 100,delayId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "delay3000"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0340";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0340";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);
    
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0340);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}
static void OnEventReceive0350(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        OH_ArkUI_AnimatorOption_SetDelay(animatorOption, -1000);
        CreateAnimatorTestLWOption(0);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retDelay = OH_ArkUI_AnimatorOption_GetDelay(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkULAnimatorOption_GetDelay == %{public}d", retDelay);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetDelay：";
        errorCode += std::to_string(retDelay);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0350(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string delayId = "delay0350";
    SetNodeID(nodeAPI, showContent, 200, 100,delayId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "delay-1000"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0350";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0350";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);
    
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0350);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0360(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(0);
        OH_ArkUI_AnimatorOption_SetDelay(animatorOption, 0);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retDelay = OH_ArkUI_AnimatorOption_GetDelay(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkULAnimatorOption_GetDelay == %{public}d", retDelay);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetDelay：";
        errorCode += std::to_string(retDelay);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);

        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0360(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string delayId = "delay0360";
    SetNodeID(nodeAPI, showContent, 200, 100,delayId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "delay0"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0360";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0360";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);
    
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0360);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0370(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(0);
        OH_ArkUI_AnimatorOption_SetDelay(animatorOption, 500);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retDelay = OH_ArkUI_AnimatorOption_GetDelay(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkULAnimatorOption_GetDelay == %{public}d", retDelay);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetDelay：";
        errorCode += std::to_string(retDelay);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);

        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(create);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0370(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string delayId = "delay0370";
    SetNodeID(nodeAPI, showContent, 200, 100,delayId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "delay500"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0370";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0370";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);
    
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0370);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0380(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, -20);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0380(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0380_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0380_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0380_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0380);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}

static void OnEventReceive0390(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, -1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0390(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0390_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0390_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0390_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0390);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}


static void OnEventReceive0400(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, 0);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0400(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0400_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0400_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0400_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0400);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}
static void OnEventReceive0410(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, 2.5);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0410(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0410_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0410_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0410_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0410);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}
static void OnEventReceive0420(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0420(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0420_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0420_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0420_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0420);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}

static void OnEventReceive0430(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetIterations(animatorOption, 5);
        OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 500);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retIterations = OH_ArkUI_AnimatorOption_GetIterations(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetIterations == %{public}d", retIterations);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetIterations：";
        errorCode += std::to_string(retIterations);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0430(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0430_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);

    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0430_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);

    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0430_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0430);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}

static void OnEventReceive0440(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(0);
        OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_NONE);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0440(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0440";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "I-noon"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0440";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0440";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0440);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0450(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_FORWARDS);
        animatorHandle = animateApi->createAnimator(context, animatorOption);	

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0450(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0450";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "I-forwards"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0450";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0450";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0450);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0460(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_BACKWARDS);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0460(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0460";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "I-forwards"};
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0460";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0460";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0460);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0470(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_BOTH);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0470(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0470";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "fill-both"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0470";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0470";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0470);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}
static void OnEventReceive0480(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_FORWARDS);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0480(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0480";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "I-forwards"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0480";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0480";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0480);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0490(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        OH_ArkUI_AnimatorOption_SetFill(nullptr, ARKUI_ANIMATION_FILL_MODE_BACKWARDS);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retFill = OH_ArkUI_AnimatorOption_GetFill(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetFill == %{public}d", retFill);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetFill：";
        errorCode += std::to_string(retFill);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0490(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0490";
    SetNodeID(nodeAPI, showContent, 200, 100, FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "I-forwards"};
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);

    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0490";
    SetNodeID(nodeAPI, create, 200, 100, createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);

    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0490";
    SetNodeID(nodeAPI, play, 200, 100, playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0490);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0500(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_0) {
        CreateAnimatorOption(3);
    }
    if (targetId == NUMBER_1) {
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(button3);
        OH_ArkUI_AnimatorOption_SetDirection(animatorOption, ARKUI_ANIMATION_DIRECTION_NORMAL);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

        ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        int32_t retDirection = OH_ArkUI_AnimatorOption_GetDirection(animatorOption);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
        "CreateNativeNode OH_ArkUI_AnimatorOption_GetDirection == %{public}d", retDirection);
        std::string errorCode = "OH_ArkUI_AnimatorOption_GetDirection：";
        errorCode += std::to_string(retDirection);
        text_item.string = errorCode.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_2) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0500(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    button1 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button1, 200,100);
    ArkUI_AttributeItem idStr1;
    idStr1.string = "Animator0500_1";
    nodeAPI->setAttribute(button1, NODE_ID, &idStr1);
    ArkUI_AttributeItem text_item1 = {.string = "animation"};
    nodeAPI->setAttribute(button1, NODE_BUTTON_LABEL, &text_item1);
    nodeAPI->registerNodeEvent(button1, NODE_ON_CLICK, NUMBER_0, nullptr);
    
    button2 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button2, 200,100);
    ArkUI_AttributeItem idStr2;
    idStr2.string = "Animator0500_2";
    nodeAPI->setAttribute(button2, NODE_ID, &idStr2);
    ArkUI_AttributeItem text_item2 = {.string = "create"};
    nodeAPI->setAttribute(button2, NODE_BUTTON_LABEL, &text_item2);
    nodeAPI->registerNodeEvent(button2, NODE_ON_CLICK, NUMBER_1, nullptr);
    
    button3 = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    SetNodeWidthAndHeight(nodeAPI, button3, 200,100);
    ArkUI_AttributeItem idStr3;
    idStr3.string = "Animator0500_3";
    nodeAPI->setAttribute(button3, NODE_ID, &idStr3);
    ArkUI_AttributeItem text_item3 = {.string = "play"};
    nodeAPI->setAttribute(button3, NODE_BUTTON_LABEL, &text_item3);
    nodeAPI->registerNodeEvent(button3, NODE_ON_CLICK, NUMBER_2, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateRegisterOnFrameCallback();
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0500);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, button1);
    nodeAPI->addChild(rootNode, button2);
    nodeAPI->addChild(rootNode, button3);
}

namespace Direction{
static ArkUI_ExpectedFrameRateRange rateRangeValue = {};
static ArkUI_NodeHandle reserveButton = nullptr;
static ArkUI_AnimationDirection directionValue = ARKUI_ANIMATION_DIRECTION_NORMAL;
static void OnEventReceive(ArkUI_NodeEvent *event)
{
    if (event == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive: event is null");
        return;
    }

    int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);

    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    auto nodeHandler = OH_ArkUI_NodeEvent_GetNodeHandle(event);
    auto nodeName = nodeAPI->getAttribute(nodeHandler, NODE_BUTTON_LABEL);
    
    if (eventId != ON_CLICK_EVENT_ID) {
        return;
    }
    
    if (strcmp(nodeName->string, "create") == 0){
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(nodeHandler);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        if(animatorHandle == NULL){
            text_item.string = "AnimatorAnimatorCTest Creates animator fail";
        }
        text_item.string = "AnimatorAnimatorCTest Creates animator success";
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
        return;
    }
    
    if(strcmp(nodeName->string, "reserve") == 0){
        OH_ArkUI_AnimatorOption_SetDirection(animatorOption, directionValue);
    }
    if(strcmp(nodeName->string, "reserve540") == 0){
        OH_ArkUI_AnimatorOption_SetDirection(nullptr, directionValue);
    }

    directionValue = OH_ArkUI_AnimatorOption_GetDirection(animatorOption);
    std::string log = "CreateNativeNode OHLArkULAnimatorOption_GetDirection == " + std::to_string(directionValue);
    text_item.string = log.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    
    if(strcmp(nodeName->string, "play") == 0){
        OH_ArkUI_Animator_Play(animatorHandle);
        return;
    }
}
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0510(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0510_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0510_P", "play");
    Direction::reserveButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0510_r", "reserve");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0510";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, Direction::reserveButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&Direction::OnEventReceive);
    CreateAnimatorTestOption(0);
    Direction::directionValue = ArkUI_AnimationDirection::ARKUI_ANIMATION_DIRECTION_REVERSE;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0520(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0520_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0520_P", "play");
    Direction::reserveButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0520_r", "reserve");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0520";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, Direction::reserveButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&Direction::OnEventReceive);
    CreateAnimatorTestOption(0);
    OH_ArkUI_AnimatorOption_SetIterations(animatorOption, NUMBER_5);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 500);
    Direction::directionValue = ArkUI_AnimationDirection::ARKUI_ANIMATION_DIRECTION_ALTERNATE;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0530(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0530_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0530_P", "play");
    Direction::reserveButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0530_r", "reserve");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0530";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, Direction::reserveButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&Direction::OnEventReceive);
    CreateAnimatorTestOption(0); 
    OH_ArkUI_AnimatorOption_SetIterations(animatorOption, NUMBER_5);
    OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 500);
    Direction::directionValue = ArkUI_AnimationDirection::ARKUI_ANIMATION_DIRECTION_ALTERNATE_REVERSE;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0540(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0540_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0540_P", "play");
    Direction::reserveButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0540_r", "reserve540");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0540";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, Direction::reserveButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&Direction::OnEventReceive);
    CreateAnimatorTestOption(0);
    Direction::directionValue = ArkUI_AnimationDirection::ARKUI_ANIMATION_DIRECTION_ALTERNATE_REVERSE;
}

namespace RateRange{
static ArkUI_ExpectedFrameRateRange rateRangeValue = {};
static ArkUI_NodeHandle rateButton = nullptr;
static void OnEventReceive(ArkUI_NodeEvent *event)
{
    if (event == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive: event is null");
        return;
    }

    int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);

    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    auto nodeHandler = OH_ArkUI_NodeEvent_GetNodeHandle(event);
    auto nodeName = nodeAPI->getAttribute(nodeHandler, NODE_BUTTON_LABEL);

    if (eventId != ON_CLICK_EVENT_ID) {
        return;
    }

    if (strcmp(nodeName->string, "create") == 0){
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(nodeHandler);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        if(animatorHandle == NULL){
            text_item.string = "AnimatorAnimatorCTest Creates animator fail";
        }
        text_item.string = "AnimatorAnimatorCTest Creates animator success";
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    
    if(strcmp(nodeName->string, "rate") == 0){
        OH_ArkUI_AnimatorOption_SetExpectedFrameRateRange(animatorOption,&rateRangeValue);
        ArkUI_ExpectedFrameRateRange *range = OH_ArkUI_AnimatorOption_GetExpectedFrameRateRange(animatorOption);
        std::string log = "CreateNativeNode OH_ArkUI_AnimatorOption_GetExpectedFrameRateRange min == "
            + std::to_string(range->min)
            + " max == "
            + std::to_string(range->max)
            + " expected == "
            + std::to_string(range->expected);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    
    if(strcmp(nodeName->string, "play") == 0){
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0550(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0550_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0550_P", "play");
    RateRange::rateButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0550_r", "rate");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0550";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, RateRange::rateButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&RateRange::OnEventReceive);
    CreateAnimatorTestOption(0);
    RateRange::rateRangeValue.min = 10;
    RateRange::rateRangeValue.max = 120;
    RateRange::rateRangeValue.expected = 60;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0560(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0560_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0560_P", "play");
    RateRange::rateButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0560_r", "rate");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0560";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, RateRange::rateButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&RateRange::OnEventReceive);
    CreateAnimatorTestOption(0);
    RateRange::rateRangeValue.min = 0;
    RateRange::rateRangeValue.max = 120;
    RateRange::rateRangeValue.expected = 60;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0580(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0580_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0580_P", "play");
    RateRange::rateButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0580_r", "rate");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0580";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, RateRange::rateButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&RateRange::OnEventReceive);
    CreateAnimatorTestOption(0);
    RateRange::rateRangeValue.min = 60;
    RateRange::rateRangeValue.max = 30;
    RateRange::rateRangeValue.expected = 20;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0590(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0590_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0590_P", "play");
    RateRange::rateButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0590_r", "rate");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0590";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, RateRange::rateButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&RateRange::OnEventReceive);
    CreateAnimatorTestOption(0);
    RateRange::rateRangeValue.min = 10;
    RateRange::rateRangeValue.max = 80;
    RateRange::rateRangeValue.expected = 100;
}

namespace BeginEnd{
static float beginValue;
static float endValue;
static ArkUI_NodeHandle setBeginEndButton = nullptr;
static void OnEventReceive(ArkUI_NodeEvent *event)
{
    if (event == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "AnimatorAnimatorCTest", "OnEventReceive: event is null");
        return;
    }

    int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);

    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    auto nodeHandler = OH_ArkUI_NodeEvent_GetNodeHandle(event);
    auto nodeName = nodeAPI->getAttribute(nodeHandler, NODE_BUTTON_LABEL);

    if (eventId != ON_CLICK_EVENT_ID) {
        return;
    }

    if (strcmp(nodeName->string, "create") == 0){
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(nodeHandler);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
        if(animatorHandle == NULL){
            text_item.string = "AnimatorAnimatorCTest Creates animator fail";
        }
        text_item.string = "AnimatorAnimatorCTest Creates animator success";
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if(strcmp(nodeName->string, "beginEnd") == 0){
        OH_ArkUI_AnimatorOption_SetBegin(animatorOption,beginValue);
        OH_ArkUI_AnimatorOption_SetEnd(animatorOption,endValue);
        //注释
        beginValue = OH_ArkUI_AnimatorOption_GetBegin(animatorOption);
        endValue = OH_ArkUI_AnimatorOption_GetEnd(animatorOption);
        std::string log = "CreateNativeNode OH_ArkUI_AnimatorOption_GetBegin == "
            + std::to_string(beginValue)
            +  " 和CreateNativeNode OH_ArkUI_AnimatorOption_GetEnd =="
            + std::to_string(endValue);
        text_item.string = log.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if(strcmp(nodeName->string, "play") == 0){
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0600(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0600_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0600_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0600_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0600";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 0;
    BeginEnd::endValue = 100;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0610(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0610_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0610_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0610_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0610";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 50;
    BeginEnd::endValue = 150;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0620(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0620_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0620_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0620_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0620";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = -200;
    BeginEnd::endValue = 500;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0630(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0630_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0630_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0630_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0630";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 200;
    BeginEnd::endValue = 200;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0640(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0640_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0640_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0640_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0640";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 500;
    BeginEnd::endValue = 0;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0650(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0650_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0650_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0650_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0650";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 0;
    BeginEnd::endValue = -200;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0660(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    createButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0660_C", "create");
    playButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0660_P", "play");
    BeginEnd::setBeginEndButton = CreateButtonWithIDAndName(nodeAPI, "OnClickButton0660_E", "beginEnd");
    std::string componentId = "NODE_TEXTINPUT_EVENT_CAPI_0660";
    logText = CreateBaseText(nodeAPI,componentId);
    nodeAPI->addChild(rootNode, createButton);
    nodeAPI->addChild(rootNode, BeginEnd::setBeginEndButton);
    nodeAPI->addChild(rootNode, playButton);
    nodeAPI->addChild(rootNode, logText);
    nodeAPI->registerNodeEventReceiver(&BeginEnd::OnEventReceive);
    CreateAnimatorTestOption(0);
    BeginEnd::beginValue = 0;
    BeginEnd::endValue = 100;
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0670(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_67);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0) 
    << "\nframeValue1 " << std::to_string(frameValue1) 
    << "\nframeValue2 " << std::to_string(frameValue2) 
    << "\nframeTime0 " << std::to_string(frameTime0) 
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0680(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_68);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0)
    << "\nframeValue1 " << std::to_string(frameValue1)
    << "\nframeValue2 " << std::to_string(frameValue2)
    << "\nframeTime0 " << std::to_string(frameTime0)
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0690(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_69);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0) 
    << "\nframeValue1 " << std::to_string(frameValue1) 
    << "\nframeValue2 " << std::to_string(frameValue2) 
    << "\nframeTime0 " << std::to_string(frameTime0) 
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);
    
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0700(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_70);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0) 
    << "\nframeValue1 " << std::to_string(frameValue1) 
    << "\nframeValue2 " << std::to_string(frameValue2) 
    << "\nframeTime0 " << std::to_string(frameTime0) 
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0710(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_71);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0) 
    << "\nframeValue1 " << std::to_string(frameValue1) 
    << "\nframeValue2 " << std::to_string(frameValue2) 
    << "\nframeTime0 " << std::to_string(frameTime0) 
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0720(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_72);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    auto frameValue0 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0);
    auto frameValue1 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1);
    auto frameValue2 = OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 2);
    auto frameTime0 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0);
    auto frameTime1 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1);
    auto frameTime2 = OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 2);
    std::stringstream ss;
    ss << "frameValue0 " << std::to_string(frameValue0) 
    << "\nframeValue1 " << std::to_string(frameValue1) 
    << "\nframeValue2 " << std::to_string(frameValue2) 
    << "\nframeTime0 " << std::to_string(frameTime0) 
    << "\nframeTime1 " << std::to_string(frameTime1)
    << "\nframeTime2 " << std::to_string(frameTime2);
    std::string value = ss.str();
    text_item.string = value.c_str();
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0730(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_73);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0740(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_74);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0750(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_75);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
    std::stringstream ss;
    ss << std::hex << address;
    std::string userDataStr = "GetKeyframeCurve：";
    userDataStr += ss.str();
    text_item.string = userDataStr.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0760(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_76);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    
    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
    std::stringstream ss;
    ss << std::hex << address;
    std::string userDataStr = "GetKeyframeCurve：";
    userDataStr += ss.str();
    text_item.string = userDataStr.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0770(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_77);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0780(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_78);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
    std::stringstream ss;
    ss << std::hex << address;
    std::string userDataStr = "GetKeyframeCurve：";
    userDataStr += ss.str();
    text_item.string = userDataStr.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);
    
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0790(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_79);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
    std::stringstream ss;
    ss << std::hex << address;
    std::string userDataStr = "GetKeyframeCurve：";
    userDataStr += ss.str();
    text_item.string = userDataStr.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0800(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_80);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0810(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_81);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
    unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
    std::stringstream ss;
    ss << std::hex << address;
    std::string userDataStr = "GetKeyframeCurve：";
    userDataStr += ss.str();
    text_item.string = userDataStr.c_str();
    nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0820(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    SetNodeButtonLabelAndEvent(nodeAPI, create, "create", NUMBER_CREATE_ANIMATOR);
    SetNodeButtonLabelAndEvent(nodeAPI, play, "play", NUMBER_START_TO_ANIMATOR);
    SetNodeTextInput(&nodeAPI, textInput);
    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    CreateAnimatorTestLOption(TEST_82);
    nodeAPI->registerNodeEventReceiver(&OnEventReceiveL);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
    nodeAPI->addChild(rootNode, textInput);
}

static void OnEventReceive0830(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        ArkUI_CurveHandle curveHandle = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_RHYTHM);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curveHandle, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
            "CreateNativeNode OH_ArkUI_AnimatorOption_GetKeyframeCurve=1 ==%{public}p", retDuration);
        unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "GetKeyframeCurve：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }
    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0830(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0830";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "animator"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0830";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0830";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0830);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0840(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        ArkUI_CurveHandle curveHandle = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_SHARP);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curveHandle, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
            "CreateNativeNode OH_ArkUI_AnimatorOption_GetKeyframeCurve=1 ==%{public}p", retDuration);
        unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "GetKeyframeCurve：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0840(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0840";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "animator"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0840";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0840";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0840);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0850(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        ArkUI_CurveHandle curveHandle = OH_ArkUI_Curve_CreateCurveByType(ARKUI_CURVE_SMOOTH);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curveHandle, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);
    
	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
            "CreateNativeNode OH_ArkUI_AnimatorOption_GetKeyframeCurve=1 ==%{public}p", retDuration);
        unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "GetKeyframeCurve：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0850(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0850";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "animator"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0850";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0850";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0850);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0860(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        ArkUI_CurveHandle curveHandle = OH_ArkUI_Curve_CreateCubicBezierCurve(0.42,0.0,0.58,1.0);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curveHandle, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
            "CreateNativeNode OH_ArkUI_AnimatorOption_GetKeyframeCurve=1 ==%{public}p", retDuration);
        unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "GetKeyframeCurve：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        OH_ArkUI_Animator_Play(animatorHandle);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0860(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0860";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "animator"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0860";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0860";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0860);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}

static void OnEventReceive0870(ArkUI_NodeEvent *event)
{
    auto targetId = OH_ArkUI_NodeEvent_GetTargetId(event);
    if (targetId == NUMBER_CREATE_ANIMATOR) {
        CreateAnimatorTestLWOption(3);
        ArkUI_ContextHandle context = OH_ArkUI_GetContextByNode(play);
        ArkUI_CurveHandle curveHandle = OH_ArkUI_Curve_CreateStepsCurve(10,true);
        OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorOption, curveHandle, 1);
        animatorHandle = animateApi->createAnimator(context, animatorOption);

	    ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr;
        OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI);
        auto retDuration = OH_ArkUI_AnimatorOption_GetKeyframeCurve(animatorOption, 1);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption",
            "CreateNativeNode OH_ArkUI_AnimatorOption_GetKeyframeCurve=1 ==%{public}p", retDuration);
        unsigned long long address = reinterpret_cast<unsigned long long>(&retDuration);
        std::stringstream ss;
        ss << std::hex << address;
        std::string userDataStr = "GetKeyframeCurve：";
        userDataStr += ss.str();
        text_item.string = userDataStr.c_str();
        nodeAPI->setAttribute(logText, NODE_TEXT_CONTENT, &text_item);
    }

    if (targetId == NUMBER_START_TO_ANIMATOR) {
        auto code = OH_ArkUI_Animator_Play(animatorHandle);
        OH_LOG_Print(LOG_APP, LOG_INFO, LOG_PRINT_DOMAIN, "OH_ArkUI_AnimatorOption", "OH_ArkUI_Animator_Play %{public}d",code);
    }
}
void UIMotionAnimationCapiAnimator::CreateMotionAnimationCapiAnimator0870(ArkUI_NativeNodeAPI_1 *nodeAPI, ArkUI_NodeHandle& rootNode)
{
    rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
    ArkUI_NodeHandle showContent = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string FillId = "Fill0870";
    SetNodeID(nodeAPI, showContent, 200, 100,FillId);
    ArkUI_AttributeItem showContentNODE_BUTTON_LABLE_Item = {.string = "animator"}; 
    nodeAPI->setAttribute(showContent, NODE_BUTTON_LABEL, &showContentNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(showContent, NODE_ON_CLICK, NUMBER_SHOW_CONTENT, nullptr);
    
    create = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string createId = "create0870";
    SetNodeID(nodeAPI, create, 200, 100,createId);
    ArkUI_AttributeItem createNODE_BUTTON_LABLE_Item = {.string = "create"};
    nodeAPI->setAttribute(create, NODE_BUTTON_LABEL, &createNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(create, NODE_ON_CLICK, NUMBER_CREATE_ANIMATOR, nullptr);
    
    play = nodeAPI->createNode(ARKUI_NODE_BUTTON);
    std::string playId = "play0870";
    SetNodeID(nodeAPI, play, 200, 100,playId);
    ArkUI_AttributeItem playNODE_BUTTON_LABLE_Item = {.string = "play"};
    nodeAPI->setAttribute(play, NODE_BUTTON_LABEL, &playNODE_BUTTON_LABLE_Item);
    nodeAPI->registerNodeEvent(play, NODE_ON_CLICK, NUMBER_START_TO_ANIMATOR, nullptr);

    OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_ANIMATE, ArkUI_NativeAnimateAPI_1, animateApi);
    nodeAPI->registerNodeEventReceiver(&OnEventReceive0870);

    logText = nodeAPI->createNode(ARKUI_NODE_TEXT);
    nodeAPI->addChild(rootNode, logText);

    nodeAPI->addChild(rootNode, showContent);
    nodeAPI->addChild(rootNode, create);
    nodeAPI->addChild(rootNode, play);
}
} // namespace ArkUICApiDemo